#! /usr/bin/python
#coding: utf-8
import MorphologicalRepresentation
import ClassifyingRepresentation
import ProjectionOfLexicoSemanticDictionary
import ProjectionOfVerbalPrepositionalFramesDic
import ProjectionOfPrepositionalFramesDic
from MorphologicalRepresentation import *

class MatrixSemanticSyntacticRepresentation:

    def __init__(self, text, ldb):
        #class instances
        self._ss = ldb.get_sort_sys()
        self._rqs = ldb.get_rqs()
        self._rm = MorphologicalRepresentation(text)
        self._rc = ClassifyingRepresentation.ClassifyingRepresentation(self._rm)
        self._arls = ProjectionOfLexicoSemanticDictionary.ProjectionOfLexicoSemanticDictionary(self._rc, ldb)
        self._arvfr = ProjectionOfVerbalPrepositionalFramesDic.ProjectionOfVerbalPrepositionalFramesDic(self._rc, ldb)
        self._arfrp = ProjectionOfPrepositionalFramesDic.ProjectionOfPrepositionalFramesDic(self._rc, ldb)
        self._rc_array = self._rc.get_array()

        #other fields
        self._nt = len(self._rc_array)
        self._nmasters = self._nt*[0]
        self._matr = []
        self._kindtext = ''
        self._leftprep = None
        self._pos = 0
        self._poscontr = 0
        self._nattr = 0
        self._mainpos = ''
        self._arrelvbdep = [{'linevb':None, 'linenoun':None, 'role': None}]
        self._arreln1n2 = [{'fnoun':None, 'snoun':None, 'role': None, 'example': None}]
        self._attributes = []
        self._posvb = None
        self._posdepword = None
        self._commapos = None
        self._numbqswd = 0
        self._numbent = 0
        self._posqswd = []
        self._depth = 0
        self._verbmag = [None]
        self._numb_free_dep = 4*[0]
        self._pos_free_dep = [self._nt*[None] for a in range(4)]
        self._nrelvbdep = 0
        self._nreln1n2 = 0
        self._nsit = 0
        self._nattr = 0
        self._leftnumber = 0
        self._posleftnoun = 0
        # Эти переменные не используются:
        self._arlssize = len(self._arls.get_array())
        self._arvfrsize = len(self._arvfr.get_array())
        self._arfrpsize = len(self._arfrp.get_array())

        #Инициализирует МССП
        for i in range(self._nt):
            #TODO: only first word is taken!!!
            w = self._rc.get_row(i).unit[0]

            locunit = self._arls.get_first_sem(w)
            entry = MatrixSymanticMatrixSemanticSyntacticRepresentationEntry(
            locunit,
            self._arls.get_rows_num_by_sem(locunit),
            None,
            [None,None],
            [None, None],
            None,
            0,
            0,
            0,
            )

            self._matr.append(entry)
        self._build()
        #print self._matr

    def _build(self):
        """
            Строит матричное представление ЕЯ текста
        """
        self._det_kindtext()
        rc = self._rc
        rc_array = rc.get_array()
        self._pos = self._pos
        #print rc_array[self._pos].mcoord
        #pdb.set_trace()
        for s in rc_array:
            if POS_TAGS.PREPOSITION in s.tclass: self.PrepProc()
            elif POS_TAGS.ADJECTIVE in s.tclass: self.AdjProc()
            elif POS_TAGS.COUNTABLE_NUMERAL in s.tclass or POS_TAGS.ORDINAL_NUMERAL in rc_array[self._pos].tclass: self.NumeralProc()
            elif POS_TAGS.NOUN in s.tclass: self.NounProc()
            elif POS_TAGS.PRONOUN in s.tclass: self.PronounProc()
            elif POS_TAGS.ADVERB in s.tclass: self.AdverbProc()
            elif POS_TAGS.VERB in s.tclass or POS_TAGS.PRICHASTIE in rc_array[self._pos].tclass: self.VerbFormProc()
            elif POS_TAGS.CONJUNCTION in s.tclass: pass
            elif 11 in s.tclass: pass #construct
            elif POS_TAGS.PROPER_NOUN in s.tclass: self.NameProc() #name
            #marker
            elif POS_TAGS.DELIMETER in rc_array[self._pos].tclass and "," in rc_array[self._pos].unit: self.CommaProc()
            self._pos += 1
        else:
            # связывает существитльное с прилагательным в случае инверсии в вопросе о признаках
            if self._kindtext == 'specqs-properties':
                self._pos -= 1
                self.FindLeftNoun()
                self._pos = self._posleftnoun
                self._posleftnoun = None
                self.NounProc()

        for m in self._matr:
            print m.locunit, m.mark, m.posdir[0], m.reldir[0]
        #print self._matr

    def _ask_advice_vb(self):
        """
            Метод просит пользователя выбрать реализуемое отношение
            в паре ГЛАГОЛ + СУЩЕСТВИТЕЛЬНОЕ
            и возвращает номер отношения, как номер строки массива arrelvbdep
        """
        return 0



    def AdjProc(self):
        self._nattr += 1
        semsit = self._arls.get_array()[self._matr[self._pos].locunit].semsit
        self._attributes.append({'place': self._pos, 'prop': semsit})

    def AdverbProc(self):
        if self.IsIntAdverbPronoun(self._pos) and self._depth==0:
            self._leftprep=None
        self.SpecQsProc()

    def CommaProc(self):
        #ind=1
        #while ind!=20 and ',' not in rc_array[ind].unit: ind++
        #self._commapos = self._pos
        ind = 1
        self._commapos = self._pos
        b1 = self._kindtext=='specqs-rol' and self._verbmag[0]==0
        b2 = self._is_int_pronoun(self._commapos+1) or self.IsIntAdverbPronoun(self._commapos+1)
        b3 = 4 in self._rc_array[self._commapos+1].tclass and self._is_int_pronoun(self._commapos+2)

        if b1 and (b2 or b3):
            #пустой оператор - запятая разделяет вопросительные слова в начале вопроса
            pass
        else:
            ind = 0
            if POS_TAGS.PRICHASTIE in self._rc_array[self._commapos+1].tclass:
                ind=1
            if self._is_int_pronoun(self._commapos+1):
                ind=2

            if POS_TAGS.PREPOSITION in self._rc_array[self._commapos+1].tclass and self._is_int_pronoun(self._commapos+2):
                ind=3

            if not ind:
                self._verbmag[self._depth]=0
                self._numb_free_dep[self._depth]=0
                for i in range(len(self._pos_free_dep[self._depth])):
                    self._pos_free_dep[self._depth][i]=0
                    if self._depth:
                        self._depth -= 1
            elif ind in [1,2,3]:
                self._depth +=1

    def _chose_noun_verb_relationship(self):
        """
           Метод предназначен для выбора пользователем нужного отоношения, что отбражается в переменной res.

           res – строка – получает значение 1 или 2 в результате уточняющего диалога с пользователем;
           если существительное в позиции pos непосредственно зависит от глагольной формы в позиции posvb,
           то res := 0; если существительное в позиции pos (с учетом предлога) непосредственно зависит от
           стоящего слева существительного в позиции posleftnoun, то res := 1
        """
        return 1

    def _choose_thematic_role(self):
        """
            Пользователю предлагается указать, какое из нескольких смысловых отношений реализуется в сочетании
            “Глагольная форма в позиции posvb + Зависимая единица в позиции posdep”.
            Для этого пользователю с помощью столбца example даются примеры сочетаний,
            в которых реализуется такое же смысловое отношение, как и потенциально
            возможное отношение между единицами текста в позициях posvb и posdep.
        """
        return 0

    def _choose_relationship_between_nouns(self):
        """
            Пользователю предлагается указать, какое из нескольких
            смысловых отношений реализуется в сочетании “Существительное 1 в позиции
            posleftnoun + зависимое Существительное 2 в позиции pos” с учетом предлога prep .
            Для этого пользователю с помощью столбца example даются примеры сочетаний,
            в которых реализуется такое же смысловое отношение,
            как и потенциально возможное отношение между единицами текста в позициях posleftnoun и pos.

            Возвращается позиция элемента в массиве
        """
        return 0

    def FindLeftNoun(self):
        self._posleftnoun=0
        p1= self._pos
        while p1>0 and not self._posleftnoun and not self._one_elem_in_array(
            [POS_TAGS.VERB,
             POS_TAGS.ADVERB,
             POS_TAGS.PRICHASTIE,
             POS_TAGS.PRONOUN,
             11,
             POS_TAGS.DELIMETER],
            self._rc_array[p1].tclass):
            p1 -= 1
            if POS_TAGS.NOUN in self._rc_array[p1].tclass and POS_TAGS.ADJECTIVE not in self._rc_array[p1].tclass:
                self._posleftnoun = p1
                break
        else:
            self._posleftnoun = None

    def FindRoleSet(self):


        if self._posdepword is not None and (self._is_noun(self._posdepword) or self._is_int_pronoun(self._posdepword)):
            self.VerbNounRelat()
        if self._is_constr(self._posdepword):
            self.VerbConstrRelat()

    def IsIntAdverbPronoun(self, num):
        return self._is_int_pronoun(num) and self._one_elem_in_array([u'КУДА',u'КОГДА',u'ОТКУДА', u'ГДЕ',u'КАК',u'КТО'], self._rc_array[num].unit)

    def NameProc(self):
        self._matr[self._pos].posdir[0] = self._pos - 1
        self._matr[self._pos].reldir[0] = 'Название'

    def NounNounRelat(self):
        grcase = line1 =line2 = numb1 =numb2 = 0
        s1 = s2 = ''
        Set1 = 4*['']
        Set2 = 4*['']
        arls = self._arls.get_array()
        arfrp = self._arfrp.get_array()

        self._nreln1n2 = 0
        g = False
        for m in self._rc_array[self._pos].mcoord:
            if g:
                break
            grcase = m.grcase
            line1=self._matr[self._posleftnoun].locunit
            numb1=self._matr[self._posleftnoun].nval

            for i1 in range(line1, line1 + numb1):
                Set1 = [self._arls.get_sort_for_item(i1, j) for j in range(4)]
                line2=self._matr[self._pos].locunit
                numb2=self._matr[self._pos].nval

                for i2 in range(line2, line2 + numb2):
                    Set2 = [self._arls.get_sort_for_item(i2, m) for m in range(4)]

                    for k1 in range(len(arfrp)):
                        if len(arfrp) > 0 and (arfrp[k1]['prep'] is None or arfrp[k1].prep.upper() == self._matr[self._pos].prep):
                            s1 = arfrp[k1]['sr1']
                            s2 = arfrp[k1]['sr2']
                            b1 = b2 = 0
                            for j in range(4):
                                #b1 = Set1[j] == s1
                                #b2 = Set2[j] == s2
                                if not b1 and Set1[j]:
                                    b1 = self._ss.is_concretisation(Set1[j], s1)
                                if not b2 and Set2[j]:
                                    b2 = self._ss.is_concretisation(Set2[j], s2)
                            if b1 and b2 and str(grcase) == arfrp[k1].grc:
                                # с другим падежом исходного слова отношения искаться не будут
                                g = True
                                #информация об отношении заносится в массив arreln1n2
                                self._nreln1n2 += 1
                                self._arreln1n2[self._nreln1n2 - 1]['fnoun'] = line1
                                self._arreln1n2[self._nreln1n2 - 1]['snoun'] = line2
                                self._arreln1n2[self._nreln1n2 - 1]['role'] = arfrp[k1]['rel']
                                self._arreln1n2[self._nreln1n2 - 1]['example'] = arfrp[k1]['ex']

    def NounProc(self):
        """

        """
        lbl = ''
        matr = self._matr
        arls = self._arls.get_array()

        if self._leftnumber:
            matr[self._pos].qt=self._leftnumber

        for m in range(self._nattr):
            matr[self._attributes[m]['place']].posdir[0] = self._pos
            matr[self._attributes[m]['place']].reldir[0]= self._attributes[m]['prop']
        else:
            matr[self._pos].nattr = self._nattr

        self._leftnumber = self._nattr = 0
        matr[self._pos].prep = self._leftprep
        self._leftprep = None

        if arls[matr[self._pos].locunit].st1 != u"сит":
            self._numbent += 1

        #метка
        for a in self._rc_array[self._pos].mcoord:
            try:
                if a.num == 1:
                    lbl="x"
                    break
                else:
                    lbl="S"
                    break
            except:
                # в морфологической информации нет данных о числе, прогоняем цикл заново
                pass

        self._matr[self._pos].mark = lbl + str(self._numbent)
        #находит предыдущее существительное для поиска связи между ним и текущим
        self.FindLeftNoun()

        # если предыдущее существительное не найдено
        if self._posleftnoun==None:
            if self._verbmag[self._depth]==None:
                self._numb_free_dep[self._depth] += 1
                self._pos_free_dep[self._depth][self._numb_free_dep[self._depth] - 1]=self._pos
            else:
                self._posvb=self._verbmag[self._depth]
                self._posdepword=self._pos
                self.VerbFormSemLink()
        else:

#            Находятся возможные смысловые связи (и их количество)
#            между рассматриваемым существительным в позиции  pos и
#            ближайшим слева существительным в позиции  postleftnoun

            self.NounNounRelat()


#                Нет семантико-синтаксического управления от
#                предыдущего существительного

            m2 = m1 = None
            if not self._nreln1n2:
                self._posvb=self._verbmag[self._depth]
                if self._posvb is not None:
                    self.VerbFormSemLink()
                else:
                    self._numb_free_dep[self._depth] += 1
                    self._pos_free_dep[self._depth][self._numb_free_dep[self._depth]]=self._pos

            else:
                self._posvb=self._verbmag[self._depth]
                if self._posvb is not None:
                    self.FindRoleSet()
                if not self._nrelvbdep:
                    # если не найдено отношения между глаголом и существительным
                    #если только 1 отношение, то вопрос не задаётся
                    if self._nreln1n2==1:
                        """
                            m2 — номер эл-та массива arreln1n2,
                            откуда берется инф-ция для MatrixSemanticSyntacticRepresentation о связи между
                            posn1 и posn2

                        """
                        m2=0
                    else:
                        #уточн вопрос для выбора отношения между существительными
                        m2 = self._choose_relationship_between_nouns()


                    """
                       Добавление в MatrixSemanticSyntacticRepresentation информации о связи между
                       единицами текста в позициях posn1 и posn2,
                       эта информация берется из позиции m2 массива arreln1n2
                    """
                    matr[self._posleftnoun].locunit = self._arreln1n2[m2]['fnoun']
                    matr[self._posleftnoun].nval=1
                    matr[self._pos].locunit=self._arreln1n2[m2]['snoun']
                    matr[self._pos].nval=1
                    matr[self._pos].posdir[0]=self._posleftnoun
                    matr[self._pos].reldir[0]=self._arreln1n2[m2]['role']
                else:
                    #возможна связь с глаголом
                    if self._nreln1n2:
                        """
                           Возможна связь и с предыдущим существительным
                        """
                        #уточн вопрос
                        res = self._chose_noun_verb_relationship()

                        if res == 1:
                            if self._nrelvbdep == 1:
                                m1 = 0
                            else:
                                m1 = self._choose_thematic_role()

                            #запись в MatrixSemanticSyntacticRepresentation информации о связи между глагольной формой в позиции posvb и
                            #существительным в позиции pos, которая берется из строки m1 массива arrelvbdep

                            self._nmasters[self._pos] += 1
                            #найдена новая управляющая стрелка, ведущая в позицию pos
                            d = self._nmasters[self._pos]
                            matr[self._pos].posdir[d] = self._posvb
                            matr[self._pos].reldir[d] = self._arrelvbdep[m1]['role']
                            matr[self._posvb].locunit = self._arrelvbdep[m1]['linevb']
                            matr[self._posvb].nval = 1
                            matr[self._pos].locunit = self._arrelvbdep[m1]['linenoun']
                            matr[self._pos].nval = 1

                        elif res == 2:
                            """
                                Нет связи с глагольной формой,
                                но есть связь с существительным в позиции posleftnoun
                            """
                            if nreln1n2 == 1:
                                m2 = 0
                            else:
                                # уточняющий вопрос
                                m2 = self._choose_relationship_between_nouns()

                            """
                               запись в MatrixSemanticSyntacticRepresentation информации о смысловой связи между
                               существительными в позициях posleftnoun и pos
                               с учетом предлога prep (возможно, prep – это пустой предлог nil),
                               которая берется из строки m2 массива arrelvbdep
                            """
                            matr[self._posleftnoun].locunit = self._arreln1n2[m2]['fnoun']
                            matr[self._posleftnoun].nval=1
                            matr[self._pos].locunit=self._arreln1n2[m2]['snoun']
                            matr[self._pos].nval=1
                            matr[self._pos].posdir[0]=self._posleftnoun
                            matr[self._pos].reldir[0]=self._arreln1n2[m2]['role']



        b = False

        try:
            # необходимо добавть сравнение сортов из ЛСС
            b = self._rc_array[self._pos].grcase == self._rc_array[self._pos + 1].grcase
        except:
            pass

        if b:
            self.PropNounProc()
        elif 2 in self._rc_array[self._pos].subclass:
            self.NameProc()

        self._leftprep=None
        self._leftnumber = self._nattr = 0
        # сбрасываем все атрибуты
        self._attributes = []

    def NounSearch(self, is_prichastie=0):
        depth = self._depth - 1 if is_prichastie else self._depth
        self._posvb=self._verbmag[self._depth-1]
        part1 = ''
        for k in range(self._pos):
            is_noun = 2 in self._rc_array[k].tclass
            is_something = self._matr[k].posdir[self._nmasters[k] + 1]==self._posvb or not self._matr[k].posdir[self._nmasters[k]]
            if(is_noun and is_something):
                self._poscontr=k
                break

    def NumeralProc(self):
        self._leftnumber = self._rc_array[self._pos].unit[0]

    def PrepProc(self):
        self._leftprep = self._rc_array[self._pos].unit[0]
        self._matr[self._pos].prep = self._leftprep

    def PronounProc(self):
        if self._is_int_pronoun(self._pos) and self._verbmag[self._depth]==None:
            self.SpecQsProc()
        else:
            if self._commapos and (',' not in self._rc_array[self._commapos-1].unit and POS_TAGS.PREPOSITION not in self._rc_array[self._commapos-1].tclass) or (POS_TAGS.PREPOSITION in self._rc_array[self._commapos-1].tclass and ',' in self._rc_array[self._commapos-2].unit):
                self._depth+=1
                self.NounSearch()
                self._matr[self._commapos].contr=self._poscontr
                self._numb_free_dep[self._depth]=1
                self._pos_free_dep[self._depth][1]=self._commapos

    def PropNounProc(self):
        arls = self._arls.get_array()
        k=self._pos+1;
        while POS_TAGS.NOUN in self._rc_array[k].tclass and 2 in self._rc_array[k].subclass:
            matr[k]['self._posdir'][0]=self._pos
            matr[k].reldir[0]=arls[matr[k].locunit]['sem']
            k += 1
        self._pos=k-1

    def SpecQsProc(self):
        #print 'a'
        if self._is_int_pronoun(self._pos) or self.IsIntAdverbPronoun(self._pos)  or u'СКОЛЬКО' in rc_array[self._pos].unit:
            k = None
            self._numbqswd += 1
            self._posqswd.append(self._pos)
            #word = self._rc.get_array()[self._pos].unit[0]
            rqs = self._rqs.get_array()

            for i in range(len(rqs)):
                if rqs[i]['prep']==self._leftprep and rqs[i]['qswd']==self._rc_array[self._pos].unit[0].lower():
                    k = i
                    break
            #если подходящее вопросительное слово существует
            if k is not None:
                self._matr[self._pos].reldir[0]=rqs[i]['relq']
                self._numbent += 1
                self._matr[self._pos].mark="x" + str(self._numbent)
                leftprep= None

    def VerbFormSemLink(self):
        m = None
        #Формирует массив arlvbdep и задаёт нужные поля
        self.FindRoleSet()
        if self._nrelvbdep==1:
            m=0
        elif not self._nrelvbdep:
            return
        else:
            #метод не реализован
            m = self._ask_advice_vb()

        matr = self._matr
        matr[self._posvb].posdir[0]=None
        matr[self._posvb].locunit = self._arrelvbdep[m]['linevb']
        matr[self._posvb].nval = 1

        #self._posdepword = self._posdepword

        if self._is_noun(self._posdepword):
            matr[self._posdepword].locunit = self._arrelvbdep[m]['linenoun']
        #есть расхождения с книгой!!!
        matr[self._posdepword].nval=1
        matr[self._posdepword].posdir[0]=self._posvb
        matr[self._posdepword].reldir[0]= self._arrelvbdep[m]['role']

    def VerbConstrRelat(self):
        startline=matr[self._posvb].locunit
        numbvalvb=matr[self._posvb].nval
        line1 = startline
        arvfr = self._arvfr.get_array()
        k = 0
        nrelvbdep = current_pred = 0

        for l in range(startline, startline + numbvalvb + 1):
            current_pred=arls[l].semsit
            for k in range(self._arvfrsize):
                if arvfr[k].str == self._rc_array[self._posdepword].subclass and matr[self._posvb].prep == arvfr[k].sprep:
                        self._nrelvbdep += 1
                        self._arrelvbdep.append({'linevb': l, 'role':arvfr[k].trole})



        self._leftprep = None

    def VerbFormProc(self):
        self._nsit+=1
        self._matr[self._pos].mark = "e"+ str(self._nsit)
        if self._depth >= len(self._verbmag):
            self._verbmag.append(None)
        self._verbmag[self._depth]=self._pos
        #причастие
        is_verb_with_noun_before = 1 in self._rc_array[self._pos].tclass and self._numb_free_dep
        is_prichastie = 6 in self._rc_array[self._pos].tclass
        if is_prichastie:
            if is_prichastie and ',' not in self._rc_array[self._pos - 1].unit:
                self._depth+=1
            self.NounSearch()
            self._matr[self._pos].contr=self._poscontr
            self._posvb=self._pos
            self._posdepword=self._poscontr
            self._nmasters[self._posdepword] += 1
            self.VerbFormSemLink()
        #print self._depth, self._numbqswd
        if (POS_TAGS.VERB in self._rc_array[self._pos].tclass and not self._depth) and self._numbqswd:
            for k in range(self._numbqswd):
                self._matr[self._posqswd[k]].posdir[0] = self._pos
            #self._numbqswd=0
        # заменено с self._numb_free_dep[self._depth]>0
        if self._numb_free_dep[self._depth]:
            for m in range(self._numb_free_dep[self._depth]):
                self._posdepword=self._pos_free_dep[self._depth][m]
                if self._posdepword is not None:
                    self.VerbFormSemLink()

    def VerbNounRelat(self):
        grcase = [{'grcase':0}]
        arls = self._arls.get_array()
        arvfr = self._arvfr.get_array()
        Set1 = 4*[None]

        self._nrelvbdep=0
        if self._posvb is None:
            self._posvb=self._pos
        #print self._posvb
        if 6 in self._rc_array[self._posvb].tclass and self._posdepword==self._matr[self._posvb].contr:
            self._matr[self._posvb].prep=None
        else: self._matr[self._posvb].prep = self._matr[self._posdepword].prep

        if self._is_int_pronoun(self._posdepword) and self._one_elem_in_array([u'КАКОЙ', u'КОТОРЫЙ'], self._rc_array[self._posdepword].unit):
            noun_position = matr[self._posdepword].contr
        else:
            noun_position=self._posdepword

        if POS_TAGS.PRICHASTIE in self._rc_array[self._posvb].tclass:
            if self._posdepword == self._matr[self._posvb].contr:
                grcase[0].grcase=1

        if self._posdepword != self._matr[self._posvb].contr or POS_TAGS.VERB in self._rc_array[self._posvb].tclass:
            #print self._posdepword +1
            # вместо падежа массив с координатами
            grcase=self._rc_array[self._posdepword].mcoord

        line1=self._matr[noun_position].locunit
        numb1=self._matr[noun_position].nval

        for i1 in range(line1, line1+numb1):

            Set1 = [self._arls.get_sort_for_item(i1, j) for j in range(4)]
            line2=self._matr[self._posvb].locunit
            numb2=self._matr[self._posvb].nval

            for i2 in range(line2, line2+numb2):
                current_pred=arls[i2].semsit
                for k1 in range(len(arvfr)):
                    if arvfr[k1].semsit == current_pred:
                        s1=arvfr[k1].str
                        do_sorts_match=0
                        for j in range(4):
                            if Set1[j] and self._ss.is_concretisation(Set1[j], s1):
                                do_sorts_match=1
                        prep = None
                        if self._matr[self._posvb].prep:
                            prep = self._matr[self._posvb].prep.lower()
                        if prep == arvfr[k1].sprep and do_sorts_match:
                            # перебираем каждый возможный падеж зависимого существительного
                            for g in grcase:
                                # если падеж существительного совпал с падежом, полученным из фрейма
                                if str(g.grcase) == arvfr[k1].grc:
                                    #отношение существует
                                    #nrelvbdep++;
                                    if self._nrelvbdep >= len(self._arrelvbdep):
                                        self._arrelvbdep.append({'linevb': None, 'linenoun': None, 'role': None, 'example': None})
                                    self._arrelvbdep[self._nrelvbdep]['linevb'] = i2
                                    self._arrelvbdep[self._nrelvbdep]['linenoun'] = i1
                                    self._arrelvbdep[self._nrelvbdep]['role'] = arvfr[k1].trole
                                    self._arrelvbdep[self._nrelvbdep]['example'] = arvfr[k1].expl
                                    self._nrelvbdep += 1
                                    break

    def _is_noun(self, n):
        return POS_TAGS.NOUN in self._rc.get_array()[n].tclass

    def _is_int_pronoun(self, n):
        return 4 in self._rc.get_array()[n].subclass

    def _is_constr(self, n):
        pass

    def _det_kindtext(self):
        """
            Определяет тип текста
        """
        rc = self._rc.get_array()
        #если вопросительно-относительное местоимение
        pn = 4 in rc[0].subclass
        # если предлог и вопросительно-относительное местоимение
        pr = 4 in rc[1].subclass and POS_TAGS.PREPOSITION in rc[0].tclass

        self._pos = 1 if pr else 0
        if pn or pr:
            #print 'got'
            m = rc[self._pos].mcoord[self._pos]
            baseform = rc[self._pos].unit
            #print index
            #print m1
            n = 1000
            if m.num:
                n = m.num
            #print baseform
            if u'КАКОЙ' in baseform:
                if n == 1:
                    self._kindtext = 'specqs-relat1'
                else:
                    self._kindtext = 'specqs-relat2'
                #PROPERTIES OF THE ENTITY
                if POS_TAGS.NOUN in rc[1].tclass and POS_TAGS.ADJECTIVE in rc[2].tclass:
                    self._kindtext = 'specqs-properties'
            if pr:
                leftprep = rc[0].unit
                if n == 1:
                    v1 = 'x1'
                else:
                    v1 = 's1'

        #works
        if not self._kindtext:
            #print rc[0].unit
            l3 = 4 in rc[0].subclass or (POS_TAGS.ADVERB in rc[0].tclass and ('ГДЕ' in rc[0].unit or u'КОГДА' in rc[0].unit or u'КУДА' in rc[0].unit or u'ОТКУДА' in rc[0].unit))

            l4 = POS_TAGS.PREPOSITION in rc[0].tclass and 4 in rc[1].subclass
            if (l3 or l4) and u'СКОЛЬКО' not in rc[0].unit:
                if l3:
                    self._pos = 0
                if l4:
                    self._pos = 1
                #print rc[self._pos].subclass
                #m1 = rc.unit
                if u'КАКОЙ' not in baseform:
                    if u'ПОЧЕМУ' in baseform:
                        self._kindtext = 'specqs-cause'

                    else:
                        self._kindtext = 'specqs-way' if u'КАК' in rc[0].unit else 'specqs-rol'
                        #DOWNLOAD FILE
                        if u'ГДЕ' in rc[0].unit and u'СКАЧАТЬ' in rc[1].unit:
                            self._kindtext = 'specqs-download'
                        if l4:
                            leftprep = rc[0].unit
                        v1 = 'x1'


        #works
        if not self._kindtext:
            if POS_TAGS.VERB in rc[0].tclass and u'ЛИ' in rc[1].unit:
                self._kindtext = 'genqs'

        #works
        if not self._kindtext:
            #print rc[1].tclass
            if u'СКОЛЬКО' in rc[0].unit and POS_TAGS.NOUN in rc[1].tclass:
                v1 = 's1'
                #print 'here'
                if 'РАЗ' not in rc[1].unit:
                    self._kindtext = 'specqs-quant1'
                    self._pos = 0
                else:
                    self._kindtext = 'specqs-quant2'
                    self._pos = 0
                    self._pos = 1
                #PRICE AND WEIGHT
            if u'СКОЛЬКО' in rc[0].unit and POS_TAGS.VERB in rc[1].tclass:
                self._kindtext = 'specqs-estimation'
                self._pos = 0



        #works
        if not self._kindtext:
            if POS_TAGS.VERB     in rc[0].tclass:
                f = rc[0].subclass
                if 8 in f or 7 in f:
                    self._kindtext = 'imp'

        if not self._kindtext:
            self._kindtext = 'stat'#

        #self._pos = self._pos

        print self._kindtext, self._pos, self._pos, self._leftprep

    def get_arls(self):
        return self._arls

    def get_matr(self):
        return self._matr

    def get_mainpos(self):
        return self._mainpos

    def get_nmasters(self):
        return self._nmasters

    def get_rc(self):
        return self._rc

    def get_numbqswd(self):
        return self._numbqswd

    def get_kindtext(self):
        return self._kindtext

    def _one_elem_in_array(self, farray, sarray):
        return any(fitem in sarray for fitem in farray)

class MatrixSymanticMatrixSemanticSyntacticRepresentationEntry:
    def __init__(self, locunit, nval,prep, posdir,reldir,mark,qt,nattr,contr):
        self.locunit = locunit
        self.nval = nval
        self.prep = prep
        self.posdir = posdir
        self.reldir = reldir
        self.mark = mark
        self.qt = qt
        self.nattr = nattr
        self.contr = contr